{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## iLQR example\n",
        "\n",
        "This notebook solves a nonlinear optimal control problem using a factor-graph formulation in GTSAM. The objective is to minimize a quadratic cost over a nonlinear dynamical system using a structure similar to iterative Linear Quadratic Regulation (iLQR). The results are compared against results from classical implementation of iLQR recursions.\n",
        "\n",
        "\n",
        "Author(s): [Zhouyu Zhang](https://zhangzdd.github.io/zzy_webpage/)\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/borglab/gtsam/blob/develop/python/gtsam/examples/iLQRExample.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
      ],
      "metadata": {
        "id": "qxiTGov-Zc3z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "GTSAM Copyright 2010-2025, Georgia Tech Research Corporation, Atlanta, Georgia 30332-0415 All Rights Reserved\n",
        "\n",
        "Authors: Frank Dellaert, et al. (see THANKS for the full author list)\n",
        "\n",
        "See LICENSE for the license information"
      ],
      "metadata": {
        "id": "4fOug0rQbWCQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Install GTSAM from pip if running in Google Colab\n",
        "try:\n",
        "    import google.colab\n",
        "    %pip install --quiet gtsam-develop\n",
        "except ImportError:\n",
        "    pass # Not in Colab"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oh-8N25oy4Ac",
        "outputId": "26cb87ae-a1d2-4bb2-e4bb-8e4e0f455290"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m27.2/27.2 MB\u001b[0m \u001b[31m18.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# iLQR Problem Setup and Algorithm Overview\n",
        "\n",
        "## Problem Statement\n",
        "\n",
        "We are solving an optimal control problem for a nonlinear system with the following discrete-time dynamics:\n",
        "\n",
        "$$\n",
        "x_{t+1} = f(x_t, u_t)\n",
        "$$\n",
        "\n",
        "where the system evolves according to:\n",
        "\n",
        "$$\n",
        "f(x_t, u_t) =\n",
        "\\begin{bmatrix}\n",
        "\\text{pos}_{t+1} \\\\\n",
        "\\text{vel}_{t+1}\n",
        "\\end{bmatrix}\n",
        "=\n",
        "\\begin{bmatrix}\n",
        "\\text{pos}_t + \\text{vel}_t \\cdot \\Delta t \\\\\n",
        "\\text{vel}_t + (u_t - 0.1 \\cdot \\text{vel}_t^2) \\cdot \\Delta t\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "We aim to drive the system from an initial state:\n",
        "\n",
        "$$\n",
        "x_0 =\n",
        "\\begin{bmatrix}\n",
        "0.0 \\\\\n",
        "1.0\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "to a goal state:\n",
        "\n",
        "$$\n",
        "x_{\\text{goal}} =\n",
        "\\begin{bmatrix}\n",
        "10.0 \\\\\n",
        "0.0\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "over a finite time horizon $N = 30$, by choosing a sequence of control inputs $ \\{u_0, u_1, \\dots, u_{N-1}\\} $ that minimize the cost function:\n",
        "\n",
        "$$\n",
        "J = \\sum_{t=0}^{N-1} \\left( \\frac{1}{2}(x_t - x_{\\text{goal}})^T Q (x_t - x_{\\text{goal}}) + \\frac{1}{2} u_t^T R u_t \\right) + \\frac{1}{2}(x_N - x_{\\text{goal}})^T Q_f (x_N - x_{\\text{goal}})\n",
        "$$\n",
        "\n",
        "where the cost matrices are:\n",
        "\n",
        "- $Q = \\text{diag}(1.0, 0.1)$: running state cost (position and velocity)\n",
        "- $R = 0.01$: running control cost\n",
        "- $Q_f = \\text{diag}(10.0, 1.0)$: final state cost\n",
        "\n",
        "---\n",
        "\n",
        "## What is iLQR?\n",
        "\n",
        "Iterative Linear Quadratic Regulator (iLQR) is an algorithm for solving nonlinear optimal control problems. It generalizes the classic LQR by iteratively approximating the nonlinear system and cost function with local linear and quadratic models.\n",
        "\n",
        "At each iteration, iLQR linearizes the dynamics around the current trajectory, solves the LQR problem to obtain updated control policies, and rolls out a new trajectory.\n",
        "\n",
        "---\n",
        "\n",
        "## iLQR Algorithm Steps\n",
        "\n",
        "1. **Initialization**:\n",
        "   - Start with an initial guess for the control sequence $ \\{u_0^{(0)}, \\dots, u_{N-1}^{(0)} \\} $\n",
        "   - Roll out the trajectory $ \\{x_0, x_1, \\dots, x_N \\} $ using the nonlinear dynamics\n",
        "\n",
        "2. **Backward Pass**:\n",
        "   - Linearize the dynamics around the nominal trajectory:\n",
        "\n",
        "     $$\n",
        "     \\delta x_{t+1} \\approx A_t \\delta x_t + B_t \\delta u_t\n",
        "     $$\n",
        "\n",
        "   - Quadratically approximate the cost-to-go using second-order Taylor expansion\n",
        "   - Solve a Riccati-like recursion to compute:\n",
        "     - Feedback gain $K_t$\n",
        "     - Feedforward term $k_t$\n",
        "\n",
        "3. **Forward Pass**:\n",
        "   - Generate a new trajectory by applying:\n",
        "\n",
        "     $$\n",
        "     u_t^{\\text{new}} = u_t + \\alpha k_t + K_t(x_t^{\\text{new}} - x_t)\n",
        "     $$\n",
        "\n",
        "   - Use line search over $\\alpha$ to ensure cost decreases\n",
        "\n",
        "4. **Repeat**:\n",
        "   - Until convergence criteria are met (e.g., change in cost or trajectory below a threshold)\n",
        "\n",
        "---\n",
        "\n",
        "## Properties of iLQR\n",
        "\n",
        "- Produces a time-varying control policy of the form $ u_t = k_t + K_t x_t $\n",
        "- Solves large-horizon problems efficiently (backward pass is linear in time)\n",
        "- Can handle nonlinear dynamics and nonzero initial conditions\n",
        "\n",
        "---\n",
        "\n",
        "## Limitations\n",
        "\n",
        "- Local method: can converge to local minima\n",
        "- Requires differentiable dynamics and cost\n",
        "- Sensitive to initialization and constraint handling\n",
        "\n",
        "---\n",
        "\n",
        "## Comparison to GTSAM-Based Optimization\n",
        "\n",
        "In this notebook, we also construct a factor graph representation of the same problem using GTSAM. Each cost term and dynamic constraint is encoded as a nonlinear factor, and the optimization is solved using Gauss-Newton or Levenberg-Marquardt methods. We compare the results (trajectory, control, and total cost) between iLQR and GTSAM to validate correctness and analyze the effect of constraint regularization.\n"
      ],
      "metadata": {
        "id": "nO8OL0K-WYwZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Classical iLQR Implmenetation (you can skip this if you want)\n",
        "import numpy as np\n",
        "\n",
        "def f(x, u, dt=0.1):\n",
        "    pos, vel = x\n",
        "    acc = u[0] - 0.1 * vel ** 2\n",
        "    next_pos = pos + vel * dt\n",
        "    next_vel = vel + acc * dt\n",
        "    return np.array([next_pos, next_vel])\n",
        "\n",
        "def linearize_dynamics(x, u, dt=0.1):\n",
        "    n = x.shape[0]\n",
        "    m = u.shape[0]\n",
        "    eps = 1e-5\n",
        "    fx = f(x, u, dt)\n",
        "    A = np.zeros((n, n))\n",
        "    B = np.zeros((n, m))\n",
        "    for i in range(n):\n",
        "        dx = x.copy()\n",
        "        dx[i] += eps\n",
        "        A[:, i] = (f(dx, u, dt) - fx) / eps\n",
        "    for j in range(m):\n",
        "        du = u.copy()\n",
        "        du[j] += eps\n",
        "        B[:, j] = (f(x, du, dt) - fx) / eps\n",
        "    return A, B\n",
        "\n",
        "def ilqr_numpy(x0, u_init, Q, R, Qf, x_goal, N, max_iter=50, tol=1e-4, dt=0.1):\n",
        "    n, m = Q.shape[0], R.shape[0]\n",
        "    u_traj = u_init.copy()\n",
        "\n",
        "    for iteration in range(max_iter):\n",
        "        # Rollout current trajectory\n",
        "        x_traj = [x0]\n",
        "        for t in range(N):\n",
        "            x_traj.append(f(x_traj[-1], u_traj[t], dt))\n",
        "\n",
        "        V_x = Qf @ (x_traj[N] - x_goal)\n",
        "        V_xx = Qf.copy()\n",
        "\n",
        "        k_list = []\n",
        "        K_list = []\n",
        "\n",
        "        for t in reversed(range(N)):\n",
        "            x = x_traj[t]\n",
        "            u = u_traj[t]\n",
        "            A, B = linearize_dynamics(x, u, dt)\n",
        "\n",
        "            dx = x - x_goal\n",
        "            l_x = Q @ dx\n",
        "            l_u = R @ u\n",
        "            l_xx = Q\n",
        "            l_uu = R\n",
        "            l_ux = np.zeros((m, n))\n",
        "\n",
        "            Q_x = l_x + A.T @ V_x\n",
        "            Q_u = l_u + B.T @ V_x\n",
        "            Q_xx = l_xx + A.T @ V_xx @ A\n",
        "            Q_uu = l_uu + B.T @ V_xx @ B\n",
        "            Q_ux = l_ux + B.T @ V_xx @ A\n",
        "\n",
        "            Q_uu_inv = np.linalg.inv(Q_uu + 1e-8 * np.eye(m))\n",
        "\n",
        "            k = -Q_uu_inv @ Q_u\n",
        "            K = -Q_uu_inv @ Q_ux\n",
        "\n",
        "            V_x = Q_x + K.T @ Q_uu @ k + K.T @ Q_u + Q_ux.T @ k\n",
        "            V_xx = Q_xx + K.T @ Q_uu @ K + K.T @ Q_ux + Q_ux.T @ K\n",
        "\n",
        "            k_list.insert(0, k)\n",
        "            K_list.insert(0, K)\n",
        "\n",
        "        # Forward pass\n",
        "        x_new = [x0]\n",
        "        u_new = []\n",
        "        x = x0.copy()\n",
        "        alpha = 1.0\n",
        "        for t in range(N):\n",
        "            dx = x - x_traj[t]\n",
        "            du = k_list[t] + K_list[t] @ dx\n",
        "            u = u_traj[t] + alpha * du\n",
        "            x = f(x, u, dt)\n",
        "            x_new.append(x)\n",
        "            u_new.append(u)\n",
        "\n",
        "        x_diff = sum(np.linalg.norm(x_new[t] - x_traj[t]) for t in range(N+1))\n",
        "        if x_diff < tol:\n",
        "            break\n",
        "        u_traj = u_new\n",
        "\n",
        "    return x_new, u_traj"
      ],
      "metadata": {
        "id": "qcjW2zkORq2u",
        "cellView": "form"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# GTSAM-Based Trajectory Optimization with Custom Factors\n",
        "\n",
        "## Overview\n",
        "\n",
        "In addition to solving the optimal control problem via iLQR, we implemented the same trajectory optimization problem using the **GTSAM (Georgia Tech Smoothing and Mapping)** library. GTSAM is a factor graph optimization framework that is particularly powerful for structure-exploiting nonlinear problems. While originally developed for SLAM and robotics problems, it is highly suitable for optimal control when the problem can be expressed in factor graph form.\n",
        "\n",
        "In our case, we modeled the trajectory optimization as a nonlinear least-squares problem over a factor graph, with each factor corresponding to:\n",
        "\n",
        "- Dynamics constraints between consecutive states and controls\n",
        "- Quadratic running cost on state and control deviation\n",
        "- Terminal state cost\n",
        "- Prior on the initial state\n",
        "\n",
        "---\n",
        "\n",
        "## Factor Graph Structure\n",
        "\n",
        "The variables in our optimization problem are:\n",
        "\n",
        "- $x_0, x_1, \\dots, x_N$ (state trajectory)\n",
        "- $u_0, u_1, \\dots, u_{N-1}$ (control inputs)\n",
        "\n",
        "The factor graph includes:\n",
        "\n",
        "1. **Initial Prior**  \n",
        "   A tight prior on $x_0$ using `PriorFactorVector` to fix the initial state:\n",
        "   $$\n",
        "   \\text{Factor:} \\quad \\|x_0 - x_{\\text{init}}\\|^2\n",
        "   $$\n",
        "\n",
        "2. **Dynamics Constraints**  \n",
        "   Modeled with a custom factor that enforces the nonlinear dynamics:\n",
        "   $$\n",
        "   \\text{Factor:} \\quad \\|f(x_t, u_t) - x_{t+1}\\|^2\n",
        "   $$\n",
        "\n",
        "3. **Running State Cost**  \n",
        "   Penalizes deviation from the goal at each time step:\n",
        "   $$\n",
        "   \\text{Factor:} \\quad \\|(x_t - x_{\\text{goal}})\\|_Q^2\n",
        "   $$\n",
        "\n",
        "4. **Running Control Cost**  \n",
        "   Penalizes control magnitude:\n",
        "   $$\n",
        "   \\text{Factor:} \\quad \\|u_t\\|_R^2\n",
        "   $$\n",
        "\n",
        "5. **Terminal Cost**  \n",
        "   A custom factor added to the final state $x_N$:\n",
        "   $$\n",
        "   \\text{Factor:} \\quad \\|(x_N - x_{\\text{goal}})\\|_{Q_f}^2\n",
        "   $$\n",
        "\n",
        "All of these are implemented as `gtsam.CustomFactor` objects with manually specified residuals and Jacobians, making this approach highly flexible and comparable to symbolic optimal control pipelines.\n",
        "\n",
        "---\n",
        "\n",
        "## Notes on Implementation\n",
        "\n",
        "- **Dynamics Residual**: The residual encodes $f(x_t, u_t) - x_{t+1}$, matching iLQR’s forward rollout. We implemented analytic Jacobians for both state and control for efficient optimization.\n",
        "  \n",
        "- **Cost Residuals**: Quadratic costs are represented as residuals of the form $x - x_{\\text{ref}}$ and $u - u_{\\text{ref}}$, and the information matrices used in each `CustomFactor` encode the weighting (i.e., $Q$, $R$, $Q_f$).\n",
        "\n",
        "- **Noise Models**:  \n",
        "   We carefully matched the cost matrices from iLQR by passing the *information matrix* (inverse covariance) to GTSAM’s `Gaussian.Information(...)`.\n",
        "\n",
        "- **Relaxed Dynamics**:  \n",
        "   We discovered that **overly tight noise models** on the dynamics (e.g., $\\sigma=1e^{-6}$) can cause GTSAM to overfit the dynamics and fail to explore alternative control paths, leading to **local minima** or convergence failures. Relaxing this to $\\sigma=1e^{-2}$ allowed the optimizer more flexibility, enabling convergence to a better solution closer to the iLQR result.\n",
        "\n",
        "---\n",
        "\n",
        "## Comparison with iLQR\n",
        "\n",
        "We ran both the GTSAM and iLQR solvers on the same task and compared:\n",
        "\n",
        "- Final trajectory and control sequence\n",
        "- Cost function values\n",
        "- Convergence speed and behavior\n",
        "\n",
        "When dynamics constraints were *relaxed appropriately*, the GTSAM trajectory matched the iLQR solution almost exactly. This demonstrates that GTSAM can replicate iLQR results while offering the benefit of symbolic graph-based optimization, extensibility to constraints, and smoother integration with SLAM or mapping pipelines.\n",
        "\n",
        "---\n",
        "\n",
        "## Takeaways\n",
        "\n",
        "- GTSAM with `CustomFactor` provides a highly modular and extensible framework for nonlinear trajectory optimization.\n",
        "- Proper **balancing of dynamics tightness** is crucial to avoid poor local minima.\n",
        "- With correct Jacobians and cost encoding, GTSAM can match classical optimal control solutions like iLQR while allowing more complex problem structure to be encoded directly.\n",
        "\n",
        "This implementation serves as a bridge between classical control algorithms and modern factor graph optimization tools.\n"
      ],
      "metadata": {
        "id": "lSjrj9rKYCMe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from functools import partial\n",
        "from typing import List, Optional\n",
        "import gtsam\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# === Dynamics function (same as your iLQR) ===\n",
        "def f(x, u, dt=0.1):\n",
        "    pos, vel = x\n",
        "    acc = u[0] - 0.1 * vel**2\n",
        "    next_pos = pos + vel * dt\n",
        "    next_vel = vel + acc * dt\n",
        "    return np.array([next_pos, next_vel])\n",
        "\n",
        "# === Dynamics residual - modified to match iLQR's linearization approach ===\n",
        "def error_dynamics(this: gtsam.CustomFactor, values: gtsam.Values,\n",
        "                   jacobians: Optional[List[np.ndarray]]) -> np.ndarray:\n",
        "    dt = 0.1\n",
        "    key_x = this.keys()[0]\n",
        "    key_u = this.keys()[1]\n",
        "    key_xp1 = this.keys()[2]\n",
        "\n",
        "    x = values.atVector(key_x)\n",
        "    u = values.atVector(key_u)\n",
        "    xp1 = values.atVector(key_xp1)\n",
        "\n",
        "    # Use the same dynamics function as iLQR\n",
        "    pred = f(x, u, dt)\n",
        "    error = pred - xp1\n",
        "\n",
        "    if jacobians is not None:\n",
        "        pos, vel = x\n",
        "\n",
        "        # Compute Jacobians analytically (same as iLQR would compute)\n",
        "        dfdx = np.zeros((2, 2))\n",
        "        dfdu = np.zeros((2, 1))\n",
        "\n",
        "        # Jacobian w.r.t. state\n",
        "        dfdx[0, 0] = 1.0  # d(next_pos)/d(pos)\n",
        "        dfdx[0, 1] = dt   # d(next_pos)/d(vel)\n",
        "        dfdx[1, 0] = 0.0  # d(next_vel)/d(pos)\n",
        "        dfdx[1, 1] = 1.0 - 0.2 * vel * dt  # d(next_vel)/d(vel)\n",
        "\n",
        "        # Jacobian w.r.t. control\n",
        "        dfdu[0, 0] = 0.0  # d(next_pos)/d(u)\n",
        "        dfdu[1, 0] = dt   # d(next_vel)/d(u)\n",
        "\n",
        "        jacobians[0] = dfdx\n",
        "        jacobians[1] = dfdu\n",
        "        jacobians[2] = -np.eye(2)  # Negative identity for x_{t+1}\n",
        "\n",
        "    return error\n",
        "\n",
        "# === State cost residual - modified to match iLQR exactly ===\n",
        "def error_state_cost_ilqr_style(x_goal: np.ndarray, this: gtsam.CustomFactor,\n",
        "                                 values: gtsam.Values,\n",
        "                                 jacobians: Optional[List[np.ndarray]]) -> np.ndarray:\n",
        "    \"\"\"\n",
        "    State cost that matches iLQR formulation: penalizes deviation from goal\n",
        "    This is equivalent to: 0.5 * (x - x_goal)^T @ Q @ (x - x_goal)\n",
        "    \"\"\"\n",
        "    x = values.atVector(this.keys()[0])\n",
        "    deviation = x - x_goal\n",
        "\n",
        "    if jacobians is not None:\n",
        "        # The Jacobian of (x - x_goal) w.r.t. x is just the identity matrix\n",
        "        jacobians[0] = np.eye(len(x))\n",
        "\n",
        "    return deviation\n",
        "\n",
        "# === Control cost residual - modified to match iLQR exactly ===\n",
        "def error_control_cost_ilqr_style(this: gtsam.CustomFactor,\n",
        "                                   values: gtsam.Values,\n",
        "                                   jacobians: Optional[List[np.ndarray]]) -> np.ndarray:\n",
        "    \"\"\"\n",
        "    Control cost that matches iLQR formulation: penalizes raw control values\n",
        "    This is equivalent to: 0.5 * u^T @ R @ u\n",
        "    \"\"\"\n",
        "    u = values.atVector(this.keys()[0])\n",
        "\n",
        "    if jacobians is not None:\n",
        "        # The Jacobian of u w.r.t. u is just the identity matrix\n",
        "        jacobians[0] = np.eye(len(u))\n",
        "\n",
        "    return u\n",
        "\n",
        "# === Problem Setup (same as your iLQR) ===\n",
        "x0 = np.array([0.0, 1.0])        # initial pos & velocity\n",
        "x_goal = np.array([10.0, 0.0])   # target pos & stop\n",
        "N = 30                           # horizon\n",
        "\n",
        "Q = np.diag([1.0, 0.1])          # running state cost\n",
        "R = np.array([[0.01]])           # running control cost\n",
        "Qf = np.diag([10.0, 1.0])        # final state cost\n",
        "\n",
        "# === Build GTSAM graph to match iLQR formulation ===\n",
        "def build_ilqr_matching_graph(N, x0, x_goal, Q, R, Qf):\n",
        "    \"\"\"\n",
        "    Build a GTSAM factor graph that exactly matches the iLQR cost structure\n",
        "    \"\"\"\n",
        "    graph = gtsam.NonlinearFactorGraph()\n",
        "\n",
        "    # Create symbols\n",
        "    X = [gtsam.symbol('x', t) for t in range(N + 1)]\n",
        "    U = [gtsam.symbol('u', t) for t in range(N)]\n",
        "\n",
        "    # Create noise models that match the iLQR cost structure\n",
        "    # Important: We need to use the square root of the cost matrices\n",
        "    # because GTSAM computes 0.5 * ||error||^2_Sigma and we want 0.5 * error^T @ Q @ error\n",
        "    Q_model = gtsam.noiseModel.Gaussian.Information(Q)\n",
        "    R_model = gtsam.noiseModel.Gaussian.Information(R)\n",
        "    Qf_model = gtsam.noiseModel.Gaussian.Information(Qf)\n",
        "\n",
        "    # Dynamics constraint - use a tight tolerance to match iLQR's exact constraint\n",
        "    dyn_model = gtsam.noiseModel.Isotropic.Sigma(2, 1e-2)\n",
        "\n",
        "    # 1. Add initial condition constraint\n",
        "    prior_model = gtsam.noiseModel.Isotropic.Sigma(2, 1e-8)\n",
        "    graph.add(gtsam.PriorFactorVector(X[0], x0, prior_model))\n",
        "\n",
        "    # 2. Add dynamics constraints\n",
        "    for t in range(N):\n",
        "        graph.add(gtsam.CustomFactor(dyn_model, [X[t], U[t], X[t+1]], error_dynamics))\n",
        "\n",
        "    # 3. Add running costs (match iLQR's cost structure exactly)\n",
        "    for t in range(N):\n",
        "        # State cost: penalize deviation from goal at each time step\n",
        "        graph.add(gtsam.CustomFactor(Q_model, [X[t]],\n",
        "                                   partial(error_state_cost_ilqr_style, x_goal)))\n",
        "\n",
        "        # Control cost: penalize raw control values\n",
        "        graph.add(gtsam.CustomFactor(R_model, [U[t]], error_control_cost_ilqr_style))\n",
        "\n",
        "    # 4. Add terminal cost\n",
        "    graph.add(gtsam.CustomFactor(Qf_model, [X[N]],\n",
        "                               partial(error_state_cost_ilqr_style, x_goal)))\n",
        "\n",
        "    return graph, X, U\n",
        "\n",
        "# === Create better initial guess that matches iLQR's typical initialization ===\n",
        "def create_ilqr_style_initial_guess(x0, x_goal, N):\n",
        "    \"\"\"\n",
        "    Create an initial guess similar to what iLQR might start with\n",
        "    \"\"\"\n",
        "    values = gtsam.Values()\n",
        "\n",
        "    # Linear interpolation for states (common iLQR initialization)\n",
        "    for t in range(N + 1):\n",
        "        alpha = t / N\n",
        "        x_interp = (1 - alpha) * x0 + alpha * x_goal\n",
        "        values.insert(gtsam.symbol('x', t), x_interp)\n",
        "\n",
        "    # Zero controls (typical iLQR initialization)\n",
        "    for t in range(N):\n",
        "        values.insert(gtsam.symbol('u', t), np.array([0.0]))\n",
        "\n",
        "    return values\n",
        "\n",
        "# === Run the optimization ===\n",
        "graph, X, U = build_ilqr_matching_graph(N, x0, x_goal, Q, R, Qf)\n",
        "values = create_ilqr_style_initial_guess(x0, x_goal, N)\n",
        "\n",
        "# Use Levenberg-Marquardt optimizer (more similar to iLQR's approach)\n",
        "params = gtsam.LevenbergMarquardtParams()\n",
        "params.setVerbosity(\"ERROR\")  # Reduce output\n",
        "params.setMaxIterations(100)\n",
        "optimizer = gtsam.LevenbergMarquardtOptimizer(graph, values, params)\n",
        "\n",
        "try:\n",
        "    result = optimizer.optimize()\n",
        "\n",
        "    # Extract trajectory\n",
        "    states_gtsam = np.array([result.atVector(X[t]) for t in range(N + 1)])\n",
        "    controls_gtsam = np.array([result.atVector(U[t]) for t in range(N)])\n",
        "\n",
        "    print(\"GTSAM optimization completed successfully!\")\n",
        "    print(f\"Final state: {states_gtsam[-1]}\")\n",
        "    print(f\"Goal state: {x_goal}\")\n",
        "    print(f\"Final error: {np.linalg.norm(states_gtsam[-1] - x_goal):.6f}\")\n",
        "\n",
        "except Exception as e:\n",
        "    print(f\"GTSAM optimization failed: {e}\")\n",
        "    states_gtsam = None\n",
        "    controls_gtsam = None\n",
        "\n",
        "# === Now run your iLQR for comparison ===\n",
        "u_init = np.array([np.zeros(1) for _ in range(N)])\n",
        "states_ilqr, controls_ilqr = ilqr_numpy(x0, u_init, Q, R, Qf, x_goal, N)\n",
        "\n",
        "states_ilqr = np.array(states_ilqr)\n",
        "controls_ilqr = np.array(controls_ilqr)\n",
        "\n",
        "print(\"\\niLQR optimization completed!\")\n",
        "print(f\"Final state: {states_ilqr[-1]}\")\n",
        "print(f\"Goal state: {x_goal}\")\n",
        "print(f\"Final error: {np.linalg.norm(states_ilqr[-1] - x_goal):.6f}\")\n",
        "\n",
        "# === Compare results ===\n",
        "if states_gtsam is not None:\n",
        "    print(f\"\\nTrajectory comparison:\")\n",
        "    print(f\"Max state difference: {np.max(np.abs(states_gtsam - states_ilqr)):.6f}\")\n",
        "    print(f\"Max control difference: {np.max(np.abs(controls_gtsam - controls_ilqr)):.6f}\")\n",
        "\n",
        "    # Plot comparison\n",
        "    plt.figure(figsize=(15, 10))\n",
        "\n",
        "    plt.subplot(2, 3, 1)\n",
        "    plt.plot(states_gtsam[:, 0], label='GTSAM Position', linewidth=2)\n",
        "    plt.plot(states_ilqr[:, 0], label='iLQR Position', linewidth=2, linestyle='--')\n",
        "    plt.legend()\n",
        "    plt.title(\"Position Comparison\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 3, 2)\n",
        "    plt.plot(states_gtsam[:, 1], label='GTSAM Velocity', linewidth=2)\n",
        "    plt.plot(states_ilqr[:, 1], label='iLQR Velocity', linewidth=2, linestyle='--')\n",
        "    plt.legend()\n",
        "    plt.title(\"Velocity Comparison\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 3, 3)\n",
        "    plt.plot(controls_gtsam[:, 0], label='GTSAM Control', linewidth=2)\n",
        "    plt.plot(controls_ilqr[:, 0], label='iLQR Control', linewidth=2, linestyle='--')\n",
        "    plt.legend()\n",
        "    plt.title(\"Control Comparison\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 3, 4)\n",
        "    plt.plot(np.abs(states_gtsam[:, 0] - states_ilqr[:, 0]), label='Position Diff')\n",
        "    plt.legend()\n",
        "    plt.title(\"Position Difference\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 3, 5)\n",
        "    plt.plot(np.abs(states_gtsam[:, 1] - states_ilqr[:, 1]), label='Velocity Diff')\n",
        "    plt.legend()\n",
        "    plt.title(\"Velocity Difference\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 3, 6)\n",
        "    plt.plot(np.abs(controls_gtsam[:, 0] - controls_ilqr[:, 0]), label='Control Diff')\n",
        "    plt.legend()\n",
        "    plt.title(\"Control Difference\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "else:\n",
        "    # Just plot iLQR results\n",
        "    plt.figure(figsize=(12, 8))\n",
        "\n",
        "    plt.subplot(2, 2, 1)\n",
        "    plt.plot(states_ilqr[:, 0], label='iLQR Position')\n",
        "    plt.legend()\n",
        "    plt.title(\"Position\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 2, 2)\n",
        "    plt.plot(states_ilqr[:, 1], label='iLQR Velocity')\n",
        "    plt.legend()\n",
        "    plt.title(\"Velocity\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 2, 3)\n",
        "    plt.plot(controls_ilqr[:, 0], label='iLQR Control')\n",
        "    plt.legend()\n",
        "    plt.title(\"Control\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.subplot(2, 2, 4)\n",
        "    plt.plot(np.linalg.norm(states_ilqr - x_goal, axis=1), label='Distance to Goal')\n",
        "    plt.legend()\n",
        "    plt.title(\"Distance to Goal\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "jBhrjey3_J8u",
        "outputId": "944bde7e-9f68-4f6f-f030-4912faa6b9aa"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GTSAM optimization completed successfully!\n",
            "Final state: [ 1.00032476e+01 -8.94305312e-03]\n",
            "Goal state: [10.  0.]\n",
            "Final error: 0.009514\n",
            "\n",
            "iLQR optimization completed!\n",
            "Final state: [ 1.00032671e+01 -8.98543275e-03]\n",
            "Goal state: [10.  0.]\n",
            "Final error: 0.009561\n",
            "\n",
            "Trajectory comparison:\n",
            "Max state difference: 0.025441\n",
            "Max control difference: 0.148897\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1000 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_total_cost(states, controls, Q, R, Qf, x_goal):\n",
        "    \"\"\"\n",
        "    Computes the total cost for a trajectory using standard LQR-style quadratic cost terms.\n",
        "    \"\"\"\n",
        "    N = len(controls)\n",
        "    total_cost = 0.0\n",
        "    for t in range(N):\n",
        "        x = states[t]\n",
        "        u = controls[t]\n",
        "        x_error = x - x_goal\n",
        "        total_cost += 0.5 * x_error.T @ Q @ x_error\n",
        "        total_cost += 0.5 * u.T @ R @ u\n",
        "    # Add final cost\n",
        "    xN_error = states[N] - x_goal\n",
        "    total_cost += 0.5 * xN_error.T @ Qf @ xN_error\n",
        "    return total_cost\n",
        "\n",
        "cost_gtsam = compute_total_cost(states_gtsam, controls_gtsam, Q, R, Qf, x_goal)\n",
        "cost_ilqr = compute_total_cost(states_ilqr, controls_ilqr, Q, R, Qf, x_goal)\n",
        "\n",
        "print(f\"\\nTotal cost comparison:\")\n",
        "print(f\"  GTSAM Cost: {cost_gtsam:.4f}\")\n",
        "print(f\"  iLQR  Cost: {cost_ilqr:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udBTRzV_StUf",
        "outputId": "277a2806-4e35-4fa1-d7bf-7a4af1bd5a9a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Total cost comparison:\n",
            "  GTSAM Cost: 314.7621\n",
            "  iLQR  Cost: 315.5805\n"
          ]
        }
      ]
    }
  ]
}